package com.mixsmart.utils;

import com.mixsmart.exception.FileNotExistException;
import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;
import java.net.URL;
import java.nio.file.Files;

/**
 * 文件工具类
 * @author lmq
 * @since 1.0
 */
public class FileUtils {

	private static final Logger log = LoggerFactory.getLogger(FileUtils.class);
	
	/**
	 * 获取文件分隔符
	 * @return 返回系统对应的分隔符
	 */
	public static String getFileSeparator() {
		return System.getProperty("file.separator");
	}
	
	/**
	 * 删除文件
	 * @param filePath 文件路径
	 * @return 成功返回：true；否则返回：false
	 */
	public static boolean deleteFile(String filePath) {
		boolean is = false;
		LoggerUtils.info(log, "删除文件...");
		if(StringUtils.isNotEmpty(filePath)) {
			File file = new File(filePath);
			if(file.exists()) {
				is = file.delete();
				if(is) {
					LoggerUtils.info(log, "["+filePath+"]文件删除[成功]..");
				} else {
					LoggerUtils.error(log, "["+filePath+"]文件删除[失败]..");
				}
			} else {
				LoggerUtils.error(log, "文件不存在["+filePath+"]");
			}
		} else {
			LoggerUtils.error(log, "文件路径为空");
		}
		return is;
	}
	
	
	/**
	 * 读取文件内容
	 * @param filePath 文件路径
	 * @param isLine 是否换行符；返回内容中是否需要加回车；true表示加回车(即：\n)；false表示不加回车
	 * @return 返回读取到的字符串
	 */
	public static String readFile(String filePath, boolean isLine) {
		StringBuilder content = null;
		if(StringUtils.isNotEmpty(filePath)) {
			File file = new File(filePath);
			if(!file.exists()) {
				LoggerUtils.error(log, "文件不存在["+filePath+"]");
			} else {
				try {
					BufferedReader buffReader = new BufferedReader(new InputStreamReader(new FileInputStream(file),"UTF-8"));
					String line = null;
					content = new StringBuilder();
					while((line = buffReader.readLine()) != null) {
						if(isLine) {
							line = line+"\n";
						}
						content.append(line);
					}
					buffReader.close();
					buffReader = null;
				} catch (FileNotFoundException e) {
					e.printStackTrace();
				} catch (Exception e) {
					e.printStackTrace();
				}
				
			}
		} else {
			LoggerUtils.error(log, "文件路径为空");
		}
		return (null == content)?null:content.toString();
	}
	
	
	/**
	 * 内容写入到文件
	 * @param contents 内容
	 * @param filePath 文件路径
	 * @param cover 如果文件存在，是否覆盖；true--表示覆盖；false -- 表示不覆盖
	 * @return 写入成功返回：true；否则返回：false
	 */
	public static boolean writeFile(String contents, String filePath, boolean cover) {
		boolean is = false;
		if(StringUtils.isNotEmpty(filePath) && StringUtils.isNotEmpty(contents)) {
			File file = new File(filePath);
			if(file.exists()) {
				LoggerUtils.error(log, "文件已存在["+filePath+"]");
				if(cover)
					file.delete();
				else 
					return is;
			}
			File dir = file.getParentFile();
			if(!dir.exists()) {
				dir.mkdirs();
			}
			try {
				BufferedWriter buffWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file,true),"UTF-8"));
				buffWriter.write(contents);
				buffWriter.flush();
				buffWriter.close();
				is = true;
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (Exception e) {
				e.printStackTrace();
			}
		} else {
			LoggerUtils.error(log, "文件路径或内容为空");
		}
		return is;
	}
	
	
	
	/**
	 * 内容写入到文件中
	 * @param filePath 文件路径
	 * @param contents 写入文件的内容
	 * @return 写入成功返回：true；否则返回：false
	 */
	public static boolean writeFile(String filePath, String contents) {
		boolean is = false;
		if(StringUtils.isNotEmpty(filePath)) {
			is = writeFile(new File(filePath), contents);
		}
		return is;
	}
	
	
	
	/**
	 * 内容写入到文件中
	 * @param file 文件对象
	 * @param contents 写入文件的内容
	 * @return 写入成功返回：true；否则返回：false
	 */
	public static boolean writeFile(File file, String contents) {
		boolean is = false;
		if(isExist(file)) {
			try {
				BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file),"UTF-8"));
				writer.write(contents);
				writer.flush();
				writer.close();
				is = true;
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}  catch (IOException e) {
				e.printStackTrace();
			}
		} else {
			LoggerUtils.error(log, "文件不存在["+file.getAbsolutePath()+"]");
		}
		return is;
	}

	/**
	 * 判断文件是否存在
	 * @param filePath 文件路径
	 * @return 如果文件存在返回：true；否则返回：false
	 * @since 2.0.8
	 */
	public static boolean isExist(String filePath) {
		if(StringUtils.isEmpty(filePath)) {
			return false;
		}
		return isExist(new File(filePath));
	}

	/**
	 * 判断文件是否存在
	 * @param file 文件对象
	 * @return 如果文件存在返回：true；否则返回：false
	 * @since 2.0.8
	 */
	public static boolean isExist(File file) {
		return (null != file && file.exists());
	}

    /**
     * 判断文是否不存在
     * @param filePath 文件路径
     * @return 如果不文件存在返回：true；否则返回：false
     */
	public static boolean isNotExist(String filePath) {
	    return !isExist(filePath);
    }

    /**
     *
     * 判断文是否不存在
     * @param file 文件对象
     * @return 如果不文件存在返回：true；否则返回：false
     */
    public static boolean isNotExist(File file) {
        return !isExist(file);
    }

    /**
     * 判断文是否不存在的断言；如果文件不存在会抛异常
     * @param filePath 文件路径
     * @return 如果不文件存在返回：true；否则返回：false
     */
    public static void isNotExistAssert(String filePath) {
        if(isNotExist(filePath)) {
            throw new FileNotExistException(filePath, true);
        }
    }

    /**
     * 判断文是否不存在的断言；如果文件不存在会抛异常
     * @param file 文件对象
     * @return 如果不文件存在返回：true；否则返回：false
     */
    public static void isNotExistAssert(File file) {
        if(isNotExist(file)) {
            throw new FileNotExistException(file.getAbsolutePath(), true);
        }
    }

	/**
	 * 下载文件
	 * @param fileUrl 文件URL
	 * @return 返回下载后的文件路径
	 */
	public static String downloadFile(String fileUrl) {
		if(StringUtils.isEmpty(fileUrl) || !StringUtils.isNetUrl(fileUrl)) {
			return fileUrl;
		}
		try {
			URL url = new URL(fileUrl);
			String suffix = StringUtils.getFileSuffix(fileUrl);
			suffix = StringUtils.isEmpty(suffix) ? "jpg" : suffix;
			File tmpFile = Files.createTempFile("tmp", "." + suffix).toFile();
			IOUtils.copy(url, tmpFile);
			return tmpFile.getAbsolutePath();
		} catch (IOException e) {
			LoggerUtils.error(log, e);
		}
		return null;
	}

}
